// 合约缓存工具类 - 处理合约数据的本地缓存
import { invoke } from '@tauri-apps/api/core'
import type { ContractInfo, ContractCategory } from '@/types/trading'

export interface ContractCacheData {
  timestamp: number
  contracts: ContractInfo[]
  categories: ContractCategory[]
  version: string
}

/**
 * 合约缓存管理类
 * 负责合约数据的本地存储和读取
 * 使用 Tauri 2.0 的 invoke 方式处理文件操作
 * 
 * 特性：
 * - 缓存文件永不过期
 * - 清除缓存时保留 contract.json 文件
 */
export class ContractCache {
  private static readonly CACHE_FILE = 'contract.json'
  private static readonly CACHE_VERSION = '1.0.0'

  /**
   * 保存合约数据到本地缓存
   */
  public static async saveContractData(contracts: ContractInfo[], categories: ContractCategory[]): Promise<boolean> {
    try {
      const cacheData: ContractCacheData = {
        timestamp: Date.now(),
        contracts,
        categories,
        version: this.CACHE_VERSION
      }

      const jsonData = JSON.stringify(cacheData, null, 2)
      
      // 使用 Tauri invoke 保存文件
      await invoke('write_cache_file', {
        filename: this.CACHE_FILE,
        content: jsonData
      })
      return true
    } catch (error) {
      return false
    }
  }

  /**
   * 从本地缓存加载合约数据
   */
  public static async loadContractData(): Promise<ContractCacheData | null> {
    try {
      // 使用 Tauri invoke 读取文件
      const jsonData = await invoke('read_cache_file', {
        filename: this.CACHE_FILE
      }) as string

      if (!jsonData) {
        return null
      }

      const cacheData: ContractCacheData = JSON.parse(jsonData)

      // 验证缓存数据格式
      if (!this.validateCacheData(cacheData)) {
        return null
      }

      // 不检查缓存过期，合约缓存永久有效
      const cacheAge = Date.now() - cacheData.timestamp
      return cacheData
    } catch (error) {
      return null
    }
  }

  /**
   * 验证缓存数据格式
   */
  private static validateCacheData(data: any): data is ContractCacheData {
    return (
      data &&
      typeof data === 'object' &&
      typeof data.timestamp === 'number' &&
      Array.isArray(data.contracts) &&
      Array.isArray(data.categories) &&
      typeof data.version === 'string'
    )
  }

  /**
   * 清除本地缓存（不删除 contract.json 文件）
   */
  public static async clearCache(): Promise<boolean> {
    try {
      return true
    } catch (error) {
      return false
    }
  }

  /**
   * 获取缓存信息
   */
  public static async getCacheInfo(): Promise<{ exists: boolean; age?: number; size?: number } | null> {
    try {
      // 使用 Tauri invoke 获取缓存信息
      const cacheInfo = await invoke('get_cache_info', {
        filename: this.CACHE_FILE
      }) as { exists: boolean; content?: string }

      if (!cacheInfo.exists || !cacheInfo.content) {
        return { exists: false }
      }

      const cacheData = JSON.parse(cacheInfo.content)
      
      return {
        exists: true,
        age: Date.now() - cacheData.timestamp,
        size: cacheInfo.content.length
      }
    } catch (error) {
      return null
    }
  }
}
